As the strategic value of software increases for many companies, software vendors continually seek out new techniques to automate the production of software and to improve quality and reduce cost and time-to-market. These techniques include component technology, visual programming, patterns and frameworks. As the complexity of software systems increase in scope and scale, companies seek techniques to manage and solve such complexities, which include recurring architectural problems, such as physical distribution, fault tolerance, replication, security, concurrency and load balancing. Additionally, the development for the Internet, while making some communications exchanges much simpler, exacerbates these architectural challenges.
In particular, one common software architectural representation is a class diagram. A class diagram presents a graphic presentation which describes the static structure of the symbols in a system, and shows a collection of declarative (static) model elements, such as classes, types, and their contents and relationships. Classes are arranged in hierarchies that share a common structure and behavior, and are associated with other classes. Class diagrams model class structure and contents using design elements such as classes, packages and objects, and also display relationships such as containment, inheritance, associations and others. A class, in the jargon of object-oriented programming, is an element that defines the structure and behavior of a set of objects in an object-oriented program. In an object-oriented application, classes have attributes (member variables), operations (member functions) and relationships with other classes.
Moreover, code generation has become popular in the context of object-relational mapping (ORM). Relational data storage systems (e.g., DB2, SQL Server, MySQL, and the like) are commonly employed to store relational data and manage associated relationships. It is desirable for software developed in source-level languages to access and manipulate the relational data stored in the relational data storage system. When the application software is managing the relational data, it is also desirable to maintain the relationships inherent in the data. In addition, any changes or modifications to the relational data should be persisted back the relational data storage system.
In general, object-oriented languages do not provide software developers with tools to manage relational data and ensure consistency of relationships. For example, when data for a one-to-many relationship such as the customer order relationship is mapped using object oriented source code, it is frequently mapped without such features. Accordingly, when objects are populated with relational data, it is typically the responsibility of the programmer to ensure that the objects are consistent with the relational data. Similarly, when an object such as an order is removed, the programmer is responsible for ensuring that all the relevant relationships are updated. If an Order is deleted, such Order must be removed from the list of orders for the related Customer.
Additionally, once data is retrieved from the Database and converted to objects, then the data access layer can lose its ability to track a change, and two separate environments, namely: the database and the memory can be considered. In the database environment rows and columns are employed and a value provides access to desired objects. In contrast, in a memory environment pointers can be typically employed and in general no value matching or comparison is performed for object identification.
Inconsistencies can occur in such environments between the database and the memory, for example during debugging operations or when objects are modified, deleted or inserted. Errors can then be triggered, to refuse persistence of data in the database. Moreover, the ordering of the issued sequel commands can further add to the complexities involved in the object relational mapping.
Furthermore, inefficiencies exist in operation of object relational mapping systems. For example, when a programmer's code induces changes in objects within a memory, an object is initially brought into memory and a copy maintained therein. Such copy can be preserved to provide for a later comparison when a persist operation is required. Creating such copies for all loaded objects can consume resources associated with the computing infrastructure.